/**
 * API 模块
 */

/**
 * 获取分类列表
 * @param {Object} source 媒体源
 * @returns {Promise<Array>} 分类列表
 */
async function getCategories(source) {
  try {
    const config = AppConfig.getConfig()
    const useProxy = config.system.proxy.enabled && config.system.proxy.url
 
    let apiUrl = source.api
    if (useProxy) {
      apiUrl = `${config.system.proxy.url}${source.api}`
    } else if (source.proxy) {
      apiUrl = `${source.proxy}${source.api}`
    }

    const headers = {
      Referer: source.url,
    }

    if (useProxy && config.system.proxy.apiKey) {
      headers["X-API-Key"] = config.system.proxy.apiKey
    }

    const response = await fetch(`${apiUrl}/api.php/provide/vod/?ac=list`, {
      headers,
    })

    const data = await response.json()
   // console.log("获取分类列表:", data)
    return data.class || []
  } catch (error) {
    console.error("获取分类失败:", error)
    return []
  }
}


/**
 * 获取媒体列表
 * @param {Object} source 媒体源
 * @param {number} page 页码
 * @param {number} category 分类ID
 * @param {string} keyword 搜索关键词
 * @returns {Promise<Object>} 媒体列表响应
 */
async function getMediaList(source, page = 1, category = 0, keyword = "",params = {}) {
  try {
    const config = AppConfig.getConfig()
    const useProxy = config.system.proxy.enabled && config.system.proxy.url

    let apiUrl = source.api
    if (useProxy) {
      apiUrl = `${config.system.proxy.url}${source.api}`
    } else if (source.proxy) {
      apiUrl = `${source.proxy}${source.api}`
    }

    const headers = {
      Referer: source.url,
    }

    if (useProxy && config.system.proxy.apiKey) {
      headers["X-API-Key"] = config.system.proxy.apiKey
    }

    const response = await fetch(
      `${apiUrl}/api.php/provide/vod/?ac=detail&pg=${page}&t=${category}&wd=${encodeURIComponent(keyword)}&${Object.entries(params).map(([key, value]) => `${key}=${value}`).join("&")}`,
      {
        headers,
      },
    )

    const data = await response.json()
    return data
  } catch (error) {
    console.error("获取媒体列表失败:", error)
    return {
      code: 0,
      msg: "获取失败",
      page: 1,
      pagecount: 1,
      limit: "20",
      total: 0,
      list: [],
    }
  }
}

/**
 * 获取媒体详情
 * @param {Object} source 媒体源
 * @param {number} id 媒体ID
 * @returns {Promise<Object|null>} 媒体详情
 */
async function getMediaDetail(source, id) {
  try {
    const config = AppConfig.getConfig()
    const useProxy = config.system.proxy.enabled && config.system.proxy.url

    let apiUrl = source.api
    if (useProxy) {
      apiUrl = `${config.system.proxy.url}${source.api}`
    } else if (source.proxy) {
      apiUrl = `${source.proxy}${source.api}`
    }

    const headers = {
      Referer: source.url,
    }

    if (useProxy && config.system.proxy.apiKey) {
      headers["X-API-Key"] = config.system.proxy.apiKey
    }

    const response = await fetch(`${apiUrl}/api.php/provide/vod/?ac=detail&ids=${id}`, {
      headers,
    })

    const data = await response.json()
    return data.list?.[0] || null
  } catch (error) {
    console.error("获取媒体详情失败:", error)
    return null
  }
}

/**
 * 解析播放地址
 * @param {string} playFrom 播放源
 * @param {string} playUrl 播放地址
 * @returns {Array} 播放信息列表
 */
function parsePlayUrls(playFrom, playUrl) {
  if (!playFrom || !playUrl) return []

  const fromList = playFrom.split("$$$")
  const urlList = playUrl.split("$$$")

  return fromList.map((from, index) => {
    const urls = urlList[index] || ""
    return {
      from,
      urls: urls
        .split("#")
        .map((item) => {
          const [name, url] = item.split("$")
          return { name, url }
        })
        .filter((item) => item.name && item.url),
    }
  })
}

/**
 * 刮削获取更多信息
 * @param {string} title 标题
 * @param {string} imdbId IMDB ID
 * @param {string} tmdbId TMDB ID
 * @returns {Promise<Object|null>} 刮削信息
 */
async function scrapeMediaInfo(title, imdbId, tmdbId) {
  try {
    const config = AppConfig.getConfig()

    // 如果未启用自动刮削，返回null
    if (!config.system.autoScrape) {
      return null
    }

    // 构建请求参数
    const params = new URLSearchParams()
    params.append("title", title)
    if (imdbId) params.append("imdb", imdbId)
    if (tmdbId) params.append("tmdb", tmdbId)
    if (config.system.tmdbApiKey) params.append("api_key", config.system.tmdbApiKey)

    // 这里应该调用后端的刮削API
    const response = await fetch(`/api/nfo?${params.toString()}`)
    return await response.json()
  } catch (error) {
    console.error("刮削信息失败:", error)
    return null
  }
}

/**
 * 获取播放历史
 * @returns {Array} 播放历史列表
 */
function getPlayHistory() {
  try {
    const history = localStorage.getItem("mediaHistory")
    return history ? JSON.parse(history) : []
  } catch (error) {
    console.error("获取播放历史失败:", error)
    return []
  }
}

/**
 * 添加播放历史
 * @param {Object} media 媒体信息
 * @param {string} from 播放源
 * @param {string} url 播放地址
 * @param {number} position 播放位置（秒）
 */
function addPlayHistory(media, from, url, position = 0) {
  try {
    const config = AppConfig.getConfig()
    if (!config.system.history.enabled) return

    const history = getPlayHistory()
    const maxItems = config.system.history.maxItems

    // 查找是否已存在
    const index = history.findIndex((item) => item.id === media.vod_id)
    const historyItem = {
      id: media.vod_id,
      title: media.vod_name,
      poster: media.vod_pic,
      from,
      url,
      position,
      timestamp: Date.now(),
    }

    if (index >= 0) {
      // 更新现有记录
      history[index] = historyItem
    } else {
      // 添加新记录
      history.unshift(historyItem)
      // 限制历史记录数量
      if (history.length > maxItems) {
        history.pop()
      }
    }

    localStorage.setItem("mediaHistory", JSON.stringify(history))
  } catch (error) {
    console.error("添加播放历史失败:", error)
  }
}

/**
 * 获取收藏列表
 * @returns {Array} 收藏列表
 */
function getFavorites() {
  try {
    const favorites = localStorage.getItem("mediaFavorites")
    return favorites ? JSON.parse(favorites) : []
  } catch (error) {
    console.error("获取收藏列表失败:", error)
    return []
  }
}

/**
 * 添加收藏
 * @param {Object} media 媒体信息
 * @returns {boolean} 是否成功
 */
function addFavorite(media) {
  try {
    const favorites = getFavorites()

    // 查找是否已存在
    const exists = favorites.some((item) => item.id === media.vod_id)
    if (exists) return false

    // 添加新收藏
    favorites.push({
      id: media.vod_id,
      title: media.vod_name,
      poster: media.vod_pic,
      type: media.type_name,
      year: media.vod_year,
      timestamp: Date.now(),
    })

    localStorage.setItem("mediaFavorites", JSON.stringify(favorites))
    return true
  } catch (error) {
    console.error("添加收藏失败:", error)
    return false
  }
}

/**
 * 移除收藏
 * @param {number} id 媒体ID
 * @returns {boolean} 是否成功
 */
function removeFavorite(id) {
  try {
    const favorites = getFavorites()
    const newFavorites = favorites.filter((item) => item.id !== id)

    if (newFavorites.length === favorites.length) return false

    localStorage.setItem("mediaFavorites", JSON.stringify(newFavorites))
    return true
  } catch (error) {
    console.error("移除收藏失败:", error)
    return false
  }
}

/**
 * 检查是否已收藏
 * @param {number} id 媒体ID
 * @returns {boolean} 是否已收藏
 */
function isFavorite(id) {
  const favorites = getFavorites()
  return favorites.some((item) => item.id === id)
}

// 导出函数
window.API = {
  getCategories,
  getMediaList,
  getMediaDetail,
  parsePlayUrls,
  scrapeMediaInfo,
  getPlayHistory,
  addPlayHistory,
  getFavorites,
  addFavorite,
  removeFavorite,
  isFavorite,
}
